import itertools
# count(start=0,step=1) 函数有两个参数，其中 step 是默认参数，可选的，默认值为 1。 该函数返回一个新的迭代器，从 start 开始，返回以 step 为步长的均匀间隔的值
# x = itertools.count(1,2)
# for k in x:
#     if k == 111:
#       break
#     else:
#         print(k, end=", ")

# cycle(iterable) 该函数会把接收到的序列无限重复下去
# x = itertools.cycle("XYZ")
# for k in x:
# 	print(k, end = ", ")

# repeat(object, times) 该函数创建一个迭代器，不断的重复 object，当然如果指定 times 的话，则只会重复 times 次
# x = itertools.repeat("XYZ")
# for k in x:
# 	print(k, end = ", ")
# x = itertools.repeat("XYZ", 3)
# print(list(x))

# chain(*iterables) 该函数创建一个新的迭代器，会将参数中的所有迭代器全包含进去
# x = itertools.chain("abc", "xyz")
# print(list(x))

'''
groupby(iterable, key=None) 分组函数，将 key 函数作用于序列的各个元素。
根据 key 函数的返回值将拥有相同返回值的元素分到一个新的迭代器。
类似于 SQL 中的 GROUP BY 操作，唯一不同的是该函数对序列的顺序有要求，
因为当 key 函数的返回值改变时，迭代器就会生成一个新的分组。
因此在使用该函数之前需要先使用同一个排序函数对该序列进行排序操作
'''
# def sortBy(score):
# 	if score > 80:
# 		return "A"
# 	elif score >= 60:
# 		return "B"
# 	else:
# 		return "C"

# scores = [81, 82, 84, 76, 64, 78, 59, 44, 55, 89]
# for m, n in itertools.groupby(scores, key=sortBy):
# 	print(m, list(n))

# scores = [81, 82, 84, 76, 64, 78, 59, 44, 55, 89]
# 先对列表用 sortBy 函数排一下序 防止出現多個分組
# scores = sorted(scores, key=sortBy)
# for m, n in itertools.groupby(scores, key=sortBy):
# 	print(m, list(n))

# compress(data, selectors) 该函数功能很简单，就是根据 selectors 中的值判断是否保留 data 中对应位置的值
# data = [81, 82, 84, 76, 64, 78]
# tf = [1, 1, 0, 1, 1, 0]
# print(list(itertools.compress(data, tf)))

# dropwhile(predicate, iterable) 创建一个迭代器，从 predicate 首次为 false 时开始迭代元素
# 即使 predicate 首次为 false 后面的元素不满足 predicate 也同样会被迭代
# x = itertools.dropwhile(lambda x: x < 5, [1,3,5,7,4,2,1])
# print(list(x))

# filterfalse(predicate, iterable) 创建一个迭代器，返回 iterable 中 predicate 为 false 的元素
# x = itertools.filterfalse(lambda x: x < 5, [1,3,5,7,4,2,1])
# print(list(x))

# islice(iterable, start, stop[, step]) 对 iterable 进行切片操作。从 start 开始到 stop 截止，同时支持以步长为 step 的跳跃。
# print(list(itertools.islice('123456789', 2)))
# print(list(itertools.islice('123456789', 2, 4)))
# print(list(itertools.islice('123456789', 2, None)))
# print(list(itertools.islice('123456789', 0, None, 2)))

# starmap(function, iterable) 从可迭代对象中获取参数来执行该函数
# print(list(itertools.starmap(pow,[(2,10), (3,3)])))

# takewhile(predicate, iterable) 创建一个迭代器，遇到 predicate 为 false 则停止迭代元素。与 dropwhile 完全相反
# x = itertools.takewhile(lambda x: x < 5, [1,3,5,7,4,2,1])
# print(list(x))

# product(*iterables, repeat=1) 输出可迭代对象的笛卡尔积，有点类似于嵌套循环。其中 repeat 可以设置循环次数
# print(list(itertools.product("ab", "12")))
# print(list(itertools.product("ab", "ab")))
# print(list(itertools.product("ab", repeat=2)))

# permutations(iterable, r=None) 返回 iterable 中长度为 r 的所有排列。默认值 r 为 iterable 的长度。即使元素的值相同，不同位置的元素也被认为是不同的
# print(list(itertools.permutations("aba", r=2)))

# combinations(iterable, r=None) 返回 iterable 中长度为 r 的有序排列。默认值 r 为 iterable 的长度。 与 permutations 操作不同的是该函数严格按照 iterable 中元素的顺序进行排列
# print(list(itertools.combinations("abc", r=2)))

# combinations_with_replacement(iterable, r=None) 返回 iterable 中长度为 r 的有序排列。默认值 r 为 iterable 的长度。 与 combinations 操作不同的是该函数允许每个元素重复出现
# print(list(itertools.combinations_with_replacement("aba", r=2)))